Developer CD Series 1994 November: Tool Chest/Dev.CD Nov 94.toast/Sample Code/Newton Sample Code 1.2/Connection Kit/Built In MetaDatas-1/Date Book MetaData

Text File | 1994-03-09 | 22.8 KB | 718 lines | [TEXT/MPS ]

/*
    Copyright:    © 1993-1994 by Apple Computer, Inc., all rights reserved.
*/

//-------------------------------------------------------------------------------------------------
//                        I M P O R T
//-------------------------------------------------------------------------------------------------
// These are the functions used to build entries for the 5 soups.

CalendarBuildMeeting :=    func( textFrame, store)
    begin
    local temp;
    if textFrame.mtgStartDate and textFrame.startTime and textFrame.mtgDuration and textFrame.title then
        begin
        temp := {viewStationery:    'meeting};
        temp.MetaDataSoupRef := store:GetSoup( "Calendar");
        temp.mtgStartDate := StringToDate( textFrame.mtgStartDate && textFrame.startTime);
        temp.mtgDuration := StringToDate( textFrame.mtgDuration) - StringToDate( "0");
        temp.mtgText := textFrame.title;
        if textFrame.text <> nil then
            begin
            temp.notesdata := StringToParagraphArray( store, textFrame.text, kWSforCalendarNote);
            end;
        if textFrame.alarm <> nil then
            begin
            temp.mtgAlarm := Floor(StringToNumber (textFrame.alarm));
            // meeting alarms are an absolute time rather than a relative one so convert if necessary
            if temp.mtgAlarm < 50000 then
                temp.mtgAlarm := temp.mtgStartDate - temp.mtgAlarm;
            end;
        end;

    return temp;
    end;

CalendarBuildRepeatMeeting :=    func( textFrame, store)
    begin
    local temp;
    if textFrame.mtgStartDate and textFrame.startTime and textFrame.mtgDuration and textFrame.title then
        begin
        temp := {viewStationery:    'repeatingMeeting};
        temp.MetaDataSoupRef := store:GetSoup ("Repeat Meetings");
        temp.mtgStartDate := StringToDate( textFrame.mtgStartDate && textFrame.startTime);
        temp.mtgDuration := StringToDate( textFrame.mtgDuration) - StringToDate( "0");
        temp.mtgText := textFrame.title;
        if textFrame.text <> nil then
            begin
            temp.notesdata := StringToParagraphArray( store, textFrame.text, kWSforCalendarNote);
            end;
        if textFrame.alarm <> nil then
            temp.mtgAlarm := Floor(StringToNumber (textFrame.alarm));
        if textFrame.mtgStopDate <> nil then
            temp.mtgStopDate := Floor(StringToNumber (textFrame.mtgStopDate));
        if textFrame.mtgInfo <> nil then
            temp.mtgInfo := Floor(StringToNumber (textFrame.mtgInfo));
        if textFrame.repeatType <> nil then
            temp.repeatType := Floor(StringToNumber (textFrame.repeatType));
        end;
    return temp;
    end;

CalendarBuildDayNote :=    func( textFrame, store)
    begin
    local temp;
    if textFrame.mtgStartDate and textFrame.title then
        begin
        temp := {viewStationery:    'CribNote};
        temp.MetaDataSoupRef := store:GetSoup ("Calendar Notes");
        temp.mtgStartDate := StringToDate( textFrame.mtgStartDate && textFrame.startTime);
        if textFrame.mtgDuration <> nil then
            temp.mtgDuration := StringToDate( textFrame.mtgDuration) - StringToDate( "0");
        temp.mtgText := textFrame.title;
        if textFrame.alarm <> nil then
            temp.mtgAlarm := Floor(StringToNumber (textFrame.alarm));
        end;
    return temp;
    end;

CalendarBuildRepeatDayNote :=    func( textFrame, store)
    begin
    local temp;
    if textFrame.mtgStartDate and textFrame.title then
        begin
        temp := {viewStationery:    'CribNote};
        temp.MetaDataSoupRef := store:GetSoup ("Repeat Notes");
        temp.mtgText := textFrame.title;
        temp.mtgStartDate := StringToDate( textFrame.mtgStartDate && textFrame.startTime);
        if textFrame.mtgDuration <> nil then
            temp.mtgDuration := StringToDate( textFrame.mtgDuration) - StringToDate( "0");
        if textFrame.mtgStopDate <> nil then
            temp.mtgStopDate := Floor(StringToNumber (textFrame.mtgStopDate));
        if textFrame.mtgInfo <> nil then
            temp.mtgInfo := Floor(StringToNumber (textFrame.mtgInfo));
        if textFrame.repeatType <> nil then
            temp.repeatType := Floor(StringToNumber (textFrame.repeatType));
        if textFrame.alarm <> nil then
            temp.mtgAlarm := Floor(StringToNumber (textFrame.alarm));
        end;
    return temp;
    end;

CalendarBuildToDoItem :=    func( textFrame, store)
    begin
    local temp;
    if textFrame.mtgStartDate and textFrame.data then
        begin
        temp := {viewStationery:    'todoitem};
        temp.MetaDataSoupRef := store:GetSoup ("To do");
        temp.mtgStartDate := StringToDate( textFrame.mtgStartDate && textFrame.startTime);
        if textFrame.mtgpriority <> nil then
            temp.mtgpriority := Floor(StringToNumber (textFrame.mtgpriority) - 1);
        if textFrame.mtgDone <> nil then
            if StrEqual (textFrame.mtgDone, "Yes") then
                temp.mtgDone := true;
            else
                temp.mtgDone := nil;
        end;
    return temp;
    end;



// Here's the code for importing the calendar. It's separate so it can be referenced
// from two slots without duplicating code. This imports a text frame that could
// generate an entry for any of 5 soups.
CalendarTabImport := func( textFrame, store )
    begin
    local soupFrame;
    if textFrame.itemType <> nil then
        begin
        if StrEqual( textFrame.itemType, "Meeting") then
            soupFrame := :BuildMeeting( textFrame, store);
        else if StrEqual( textFrame.itemType, "Repeating Meeting") then
            soupFrame := :BuildRepeatMeeting( textFrame, store);
        else if StrEqual( textFrame.itemType, "Day Note") then
            soupFrame := :BuildDayNote( textFrame, store);
        else if StrEqual( textFrame.itemType, "Repeating Day Note") then
            soupFrame := :BuildRepeatDayNote( textFrame, store);
        else if StrEqual( textFrame.itemType, "To Do Item") then
            soupFrame := :BuildToDoItem( textFrame, store);
        end
    else
        begin
        if textFrame.mtgStartDate <> nil then
            if textFrame.title <> nil then
                if textFrame.freq <> nil then
                    if textFrame.mtgDuration <> nil then
                        soupFrame := :BuildRepeatMeeting( textFrame, store);
                    else
                        soupFrame := :BuildRepeatDayNote( textFrame, store);
                else
                    if (textFrame.mtgpriority <> nil) or (textFrame.mtgdone <> nil) then
                        soupFrame := :BuildToDoItem( textFrame, store);
                    else if textFrame.mtgDuration <> nil then
                        soupFrame := :BuildMeeting( textFrame, store);
                    else
                        soupFrame := :BuildDayNote( textFrame, store);
        end;

    :entryValidation(soupFrame, store);
    end;

//-------------------------------------------------------------------------------------------------
//                        E X P O R T
//-------------------------------------------------------------------------------------------------
ExportCalendarText := func (data)
    begin
        local result := nil;
        if data then
            begin
            // First make an array of the text slot indexes in the order of the top value in the viewbounds
            // Need to do this because the paragraphs are stored in the array in the order the user enters them,
            // not in the top to bottom order I want.
            local tops := [];
            foreach index, datum in data do
                if datum.text and not datum.copyProtection then
                    AddArraySlot (tops, {top: datum.viewbounds.top, index: index});
            Sort(tops, '|<|, 'top);

            foreach which in tops do
                begin
                theText := data[which.index].text;
                if result then
                    result := Stringer([result, "\n", theText]);
                else
                    result := theText;
                end;
            end;
        if not result then
            result := "";
        return result;
    end;

CalendarCommonExport := func( soupFrame, store )
    begin
    // Possible values for viewStationery are: 'meeting, 'repeatingMeeting, 'exceptionMeeting, 'CribNote, 'todoitem
    local textFrame := {originalFrame: soupFrame};

    if soupFrame.viewStationery = 'todoitem then
        begin
        if (soupFrame.mtgpriority) and (soupFrame.mtgpriority <> 3) then
            textFrame.mtgpriority := :getPriorityString( soupFrame);
        textFrame.completed := :getCompletedString(soupFrame);
        end;

    if (soupFrame.mtgDuration) then
        begin
        if (soupFrame.mtgDuration >= 60) then
            textFrame.mtgDuration := TimeStr(soupFrame.mtgDuration, 129);
        else
            if (soupFrame.mtgDuration <> 0) then
                textFrame.mtgDuration := "0:" & TimeStr(soupFrame.mtgDuration, 2);
        end;

    if (soupFrame.mtgStartDate) then
        textFrame.startTime := HourMinute( soupFrame.mtgStartDate);

    if (soupFrame.mtgStartDate) then
        begin
        textFrame.mtgStartDate := ShortDateStr(soupFrame.mtgStartDate, 0);
        textFrame.day := LongDateStr(soupFrame.mtgStartDate, 2);
        end;

    if (soupFrame.notesdata) then
        textFrame.text := :exportText(soupFrame.notesdata);

    local title := :getStandardTitleString(soupFrame);
    if title <> nil then
        textFrame.title := title;

    local itemType := :getStandardTypeString(soupFrame);
    if itemType <> nil then
        textFrame.itemType := itemType;

    textFrame;
    end;


CalendarTabExport := func( soupFrame, store )
    begin
    local textFrame := :commonExport (soupFrame, store);
    if (soupFrame.repeatTemplate) then
        begin
        textFrame.freq := NumberStr(soupFrame.repeatTemplate.mtgStartDate)
                            && NumberStr( soupFrame.repeatTemplate.mtgStopDate)
                            && NumberStr( soupFrame.repeatTemplate.repeatType)
                            && NumberStr( soupFrame.repeatTemplate.mtgInfo);
        end;
    if not (textFrame.itemType Exists) then
        textFrame := nil;
    if (soupFrame.mtgAlarm) then
        textFrame.alarm := NumberStr (soupFrame.mtgAlarm);
    textFrame;
    end;

CalendarBrowserExport := func( soupFrame, store )
    begin
    local textFrame := :commonExport (soupFrame, store);
    local viewStationery := soupFrame.viewStationery;

    // A few special types of entries are only exported for the browser/editor
    local itemType := :getNonStandardTypeString(soupFrame);
    if (itemType <> nil) then
        textFrame.itemType := itemType;
    if viewStationery = 'para then
        if soupFrame.text <> nil then
            textFrame.title := :getNonStandardTitleString(soupFrame);

    if (soupFrame.mtgAlarm) then
        begin
        local alarm := soupFrame.mtgAlarm;
        textFrame.alarm := "";
        // meetings have an absolute date rather than a relative date so I convert it here
        if alarm > 50000 and viewStationery = 'meeting then
            alarm := soupFrame.mtgStartDate - alarm;
        if (viewStationery = 'CribNote) then
            textFrame.alarm := DateNTime (soupFrame.mtgStartDate - alarm);
        else if alarm > 50000 then            // Still need this for not repeating daynotes
            textFrame.alarm := DateNTime (alarm);
        else if alarm > (60 * 24) then
            textFrame.alarm := NumberStr (alarm / (60 * 24)) && "days ";
        else if alarm > 60 then
            textFrame.alarm := textFrame.alarm & NumberStr (alarm / 60) && "hours ";
        else if alarm <> 0 then
            textFrame.alarm := textFrame.alarm & NumberStr (alarm) && "minutes";
        end;

    if soupFrame.mtgStopDate <> nil and soupFrame.mtgStopDate <> kForever then
        textFrame.mtgStopDate := ShortDateStr (soupFrame.mtgStopDate, 0);

    if (soupFrame.mtgInfo <> nil) and (soupFrame.repeatType <> nil) then
        textFrame.freq := RepeatInfoToText (soupFrame.mtgInfo, soupFrame.repeatType);

    textFrame;
    end;

//-------------------------------------------------------------------------------------------------
//                        M E T A  D A T A
//-------------------------------------------------------------------------------------------------
calendarmetadata :=  {
    soup: "Calendar",
    name: "Date Book",
    version: 2,
    dependents: ["Repeat Meetings",
                 "Calendar Notes",
                 "Repeat Notes",
                 "To do"],
    soupinfo: {applications: ['Calendar], itemNames: ["date", "dates"]},
    soupindicies: [{structure: 'slot, path: 'mtgStartDate, type: 'Int},
                   {structure: 'slot, path: 'mtgAlarm, type: 'Int}],

    defaultDefinitions: {
        itemType:        {label:"Type",            type:'itemType,                        compareScript: 'typeCompare},
        mtgStartDate:    {label:"Date",            type:'dateNTime,                    compareScript: 'startDateCompare},
        day:            {label:"Day",            type:'day,            path:'mtgStartDate},
        startTime:        {label:"Start Time",    type:'time,            path:'mtgStartDate},
        title:            {label:"Title",                                                compareScript: 'titleCompare},
        mtgDuration:    {label:"Duration",        type:'duration},
        freq:            {label:"Repeat info",    type:'date,            uneditable: true,     unsearchable: true},
        mtgStopDate:    {label:"Stop Date",        type:'dateNTime},
        text:            {label:"Notes",            type:'text,                            compareScript: 'notesCompare,    uneditable: true},
        alarm:            {label:"Alarm",                             path:'mtgAlarm,                    unsearchable: true},
        mtgPriority:    {label:"Priority",                                            compareScript: 'priorityCompare},
        completed:        {label:"Completed",                         path:'mtgDone,    compareScript: 'completedCompare},
        },

    displayInfo: [
        'itemType,
        'mtgStartDate,
        'day,
        'startTime,
        'title,
        'mtgDuration,
        {slot: 'freq,             hidden: TRUE},
        {slot: 'mtgStopDate,     hidden: TRUE},
        {slot: 'text,             hidden: TRUE},
        {slot: 'alarm,             hidden: TRUE},
        {slot: 'mtgPriority,     hidden: TRUE},
        {slot: 'completed,         hidden: TRUE},
        ],

    // This was never fully debugged since it's not supported in Newton Connection.
    // It's provided here for completness.
    editInfo: [
        'itemType,
        'mtgStartDate,
        'startTime,
        'mtgDuration,
        'title,
        'text,
        'alarm,
        'freq,
        'mtgStopDate,
        'mtgPriority,
        'completed,
        ],

    exportInfo: [
        'itemType,
        'day,
        'mtgStartDate,
        'startTime,
        'mtgDuration,
        'title,
        'text,
        'alarm,
        'freq,
        'mtgStopDate,
        'mtgPriority,
        'completed
        ],

    editTypes:{
            itemType: {
                type:'PICKLIST,
                choices:[
                    "Day Note",
                    "Meeting",
                    "Repeating Day Note",
                    "Repeating Meeting",
                    "To Do Item",
                    ]
                },
            },

    compareScripts: {
        startDateCompare:
            func(entry, args)
                begin
                local result;
                if entry.mtgStartDate exists then
                    if (args.searchType <= 3) then
                        result := ShortDateStr(entry.mtgStartDate, 0);
                    else
                        result := entry.mtgStartDate - (entry.mtgStartDate mod 1440);
                return result;
                end,
        completedCompare:
            func(entry, args)
                begin
                local result;
                if (entry.viewStationery = 'todoitem) then
                    result := :getCompletedString(entry);
                return result;
                end,
        priorityCompare:
            func(entry, args)
                begin
                return :getPriorityString( entry);
                end,
        notesCompare:
            func(entry, args)
                begin
                local result;
                if (entry.notesdata) then
                    result := :exportText(entry.notesdata);
                return result;
                end,
        titleCompare:
            func(entry, args)
                begin
                return :getTitleString(entry);
                end,
        typeCompare:
            func(entry, args)
                begin
                return :getTypeString(entry);
                end,
        },

    buildMeeting: CalendarBuildMeeting,
    buildRepeatMeeting: CalendarBuildRepeatMeeting,
    buildDayNote: CalendarBuildDayNote,
    buildRepeatDayNote: CalendarBuildRepeatDayNote,
    buildToDoItem: CalendarBuildToDoItem,
    tabImport:     calendarTabImport,
    editImport: calendarTabImport,

    commonExport: CalendarCommonExport,
    browseEditExport: CalendarBrowserExport,
    exportText: ExportCalendarText,

    tabExport: CalendarTabExport,
    editExport: func( soupFrame, store )
            :browseEditExport ( soupFrame, store ),
    browserExport: func( soupFrame, store )
            :browseEditExport ( soupFrame, store ),

    // ----------------------------------------------------------------------------------------
    //    Functions used in common by CompareScripts and Export
    // ----------------------------------------------------------------------------------------
    getCompletedString: func( entry)
        begin
        local result;
        if (entry.mtgDone) then
            result := "Yes";
        else
            result := "No";
        return result;
        end,

    getPriorityString: func( entry)
        begin
        local result;
        if (entry.mtgPriority) and (entry.mtgPriority <> 3) then
            result := NumberStr(entry.mtgpriority + 1);
        return result;
        end,

    getStandardTitleString: func( entry)
        begin
        local result;
        local viewStationery := entry.viewStationery;
        if (viewStationery = 'meeting) or (viewStationery = 'repeatingMeeting) or (viewStationery = 'CribNote) then
            result := entry.mtgText;
        else if viewStationery = 'todoitem then
            result := :exportText(entry.data);
        return result;
        end,

    getNonStandardTitleString: func( entry)
        begin
        local result;
        if (entry.viewStationery = 'para) and (entry.text <> nil) then
            result := entry.text;
        return result;
        end,

    getTitleString: func( entry)
        begin
        local result := :getStandardTitleString(entry);
        if (result = nil) then
            result := :getStandardTitleString(entry);
        return result;
        end,

    getStandardTypeString: func(entry)
        begin
        local result;
        local viewStationery := entry.viewStationery;
        if viewStationery = 'meeting then
            result := "Meeting";
        else if (viewStationery = 'repeatingMeeting)
            or (viewStationery = 'exceptionMeeting) then
            result := "Repeating Meeting";
        else if viewStationery = 'todoitem then
            result := "To Do Item";
        else if viewStationery = 'CribNote then
            if (entry.repeatType <> nil) or (entry.mtgStopDate <> nil) or (entry.repeatTemplate <> nil) or (entry.freq <> nil) then // this is repeating crib note
                result := "Repeating Day Note";
            else
                result := "Day Note";
        return result;
        end,

    getNonStandardTypeString: func(entry)
        begin
        local result;
        local viewStationery := entry.viewStationery;
        if viewStationery = nil then
            begin
            if entry.ink <> nil then
                result := "Ink";
            else
                result := "Unknown";
            end
        else if viewStationery = 'poly then
            result := "Graphic";
        else if viewStationery = 'para then
            result := "Paragraph";
        return result;
        end,

    getTypeString: func(entry)
        begin
        local result := :getStandardTypeString(entry);
        if (result = nil) then
            result := :getNonStandardTypeString(entry);
        return result;
        end,

    // ----------------------------------------------------------------------------------------
    //        V A L I D A T I O N
    // ----------------------------------------------------------------------------------------
    // These frames describe the slots of the soups frames and how they should be validated
    calendarValidation: {
        viewStationery: {validType: ['meeting, 'repeatingMeeting, 'cribNote], required: true},
        mtgStartDate:        {validType: 'int, required: true},
        mtgDuration:        {validType: 'int, required: true},
        mtgText:                {validType: 'string, required: true},
        mtgStopDate:        {validType: 'int},
        repeatType:            {validType: [kDayOfWeek, kWeekInMonth, kDateInMonth, kDateinYear, kPeriod, kNever]},
        mtgInfo:                {validType: 'int},
        mtgAlarm:                {validType: 'int},
        notesData:            {validType: 'note, noteMaxWidth: 224, nilOK: true},
        viewBounds:            {validType: 'rect},
        },

    dayNoteValidation: {
        viewStationery: {validType: ['cribNote], required: true},
        mtgStartDate:        {validType: 'int, required: true},
        mtgDuration:        {validType: 'int},
        mtgText:                {validType: 'string, required: true},
        mtgStopDate:        {validType: 'int},
        repeatType:            {validType: [kDayOfWeek, kWeekInMonth, kDateInMonth, kDateinYear, kPeriod, kNever]},
        mtgInfo:                {validType: 'int},
        mtgAlarm:                {validType: 'int},
        notesData:            {validType: 'note, noteMaxWidth: 224, nilOK: true},
        viewBounds:            {validType: 'rect},
        },

    todoValidation: {
        viewStationery: {validType: ['todoitem], required: true},
        mtgStartDate:        {validType: 'int, required: true},
        mtgDone:                {validType: [nil, true], required: true, nilOK: true},
        mtgPriority:        {validType: [0, 1, 2, 3], required: true},
        data:                        {validType: 'note, noteMaxWidth: 204, nilOK: true},
        },

    calendarParaFormat: {
        lineHeight:                16,
        maxRight:                    224,
        defaultFontSpec:    bor(tsSimple,tsSize(12)),
        maxBottom:                151,
        },

    toDoParaFormat: {
        lineHeight:                16,
        maxRight:                    204,
        defaultFontSpec:    bor(tsSimple,tsSize(12)),
        maxBottom:                1000,
        },

    entryValidation: func (toValidate, store)
        begin
        if not IsFrame (toValidate) then
            return "a Calendar entry was invalid";
        if toValidate.viewStationery = nil then
            begin
            if toValidate.ink = nil then
                return "a Calendar entry was invalid";
            else
                // it's ink
                toValidate := VerifyParagraphScript (toValidate, 226, "Calendar");
            end;
        else if (toValidate.viewStationery = 'para) or
                        (toValidate.viewStationery = 'poly) then
            toValidate := VerifyParagraphScript (toValidate, 226, "Calendar");
        else if toValidate.viewStationery = 'todoitem then
            begin
            toValidate := ValidateSlots ("Calendar", toValidate, todoValidation);
            if IsFrame (toValidate) then // It passed
                toValidate := ValidateNotes(toValidate, 'data, toDoParaFormat, store);
            // only now can we ensure that it has a height
            // DockerFlowParagraph the title, loop
            local deepest;

            if (toValidate.height <> nil) and (ClassOf(toValidate.height) = 'Int) then
                deepest := toValidate.height;
            else
                deepest := 0;

            if IsArray(toValidate.data) then
                foreach paragraph in toValidate.data do
                    if paragraph.viewBounds.bottom > deepest then
                        deepest := paragraph.viewBounds.bottom;

            toValidate.height := deepest;
            end
        else
            begin
            if toValidate.viewStationery = 'CribNote then
                toValidate := ValidateSlots ("Calendar", toValidate, dayNoteValidation);
            else
                toValidate := ValidateSlots ("Calendar", toValidate, calendarValidation);
            if IsFrame(toValidate) then
                begin
                // Now do the special validation
                if toValidate.mtgStopDate Exists then
                    if toValidate.mtgStopDate < toValidate.mtgStartDate and toValidate.mtgStopDate <> kForever then
                        return "a Calendar entry contained a start date that was after the stop date";

                // Make sure the high 16 bits of the mtgInfo are 0
                if toValidate.mtgInfo Exists then
                    toValidate.mtgInfo := band (toValidate.mtgInfo, 0xFFFF);

                if ((toValidate.repeatType Exists) and not (toValidate.mtgInfo Exists)) or
                     ((not toValidate.repeatType Exists) and (toValidate.mtgInfo Exists)) then
                    return "a Calendar entry contained an invalid repeating meeting";

                toValidate := ValidateNotes(toValidate, 'notesData, calendarParaFormat, store);

                end;
            end;
        return toValidate;
        end,
};

//=============================================================================
// RepeatMeetings
//=============================================================================

RepeatMeetingsMeta :=  {
    soup: "Repeat Meetings",
    name: "Repeating Meetings",
    editwith: 'Calendar,
    version: 2,
    soupInfo: {applications: ['Calendar], itemNames: ["date", "dates"]},
    soupIndicies: [{structure: 'slot, path: 'mtgStopDate, type: 'Int},
                   {structure: 'slot, path: 'mtgAlarm, type: 'Int}],
};

//=============================================================================
// RepeatNotes
//=============================================================================

RepeatNotesMeta :=  {
    soup: "Repeat Notes",
    name: "Repeating Notes",
    editwith: 'Calendar,
    version: 2,
    soupInfo: {applications: ['Calendar], itemNames: ["meeting note", "meeting notes"]},
    soupIndicies: [{structure: 'slot, path: 'mtgStopDate, type: 'Int},
                   {structure: 'slot, path: 'mtgAlarm, type: 'Int}],
};

//=============================================================================
// TodoSoup
//=============================================================================

#define todoWidth 198

TodoMeta :=  {
    soup: "To do",
    name: "To do",
    editwith: 'Calendar,
    version: 2,
    soupInfo: {applications: ['Calendar], itemNames: ["todo item", "todo items"]},
    soupIndicies: [{structure: 'slot, path: 'mtgStartDate, type: 'Int},
                   {structure: 'slot, path: 'mtgAlarm, type: 'Int}],

};

//=============================================================================
// CalendarNotes
//=============================================================================

CalendarNotesMeta :=  {
    soup: "Calendar Notes",
    name: "Calendar Notes",
    editwith: 'Calendar,
    version: 2,
    soupInfo: {applications: ['Calendar], itemNames: ["meeting note", "meeting notes"]},
    soupindicies: [{structure: 'slot, path: 'mtgStartDate, type: 'Int},
                   {structure: 'slot, path: 'mtgAlarm, type: 'Int}],
};